// 模板管理

package template

import (
	dbModel "ZHONGYIHANGYAN/bean/dbModel"
	"ZHONGYIHANGYAN/cfg"
	commUtils "ZHONGYIHANGYAN/commUtils"
	"ZHONGYIHANGYAN/mysql"
	"fmt"
	"time"
	"gorm.io/gorm"
)

type TemplateManage struct {
	mysql.DataBase
}

var defaultTemplateManage = &TemplateManage{}

func Manage() *TemplateManage {
	return defaultTemplateManage
}

// 初始化通道相关的表
func InitTable(DB *mysql.MysqlGorm) {
	defaultTemplateManage.DataBase = DB

	/* 自动创建表结构 */
	defaultTemplateManage.autoMigrate()

	// 创建默认模板和指标数据
	defaultTemplateManage.CreateDefaultTemplateAndQuota()
}

// 自动创建表结构
func (m *TemplateManage) autoMigrate() {
	m.DataBase.AutoMigrate(&dbModel.Template{})
	m.DataBase.AutoMigrate(&dbModel.Quota{})
}

// 创建默认模板和指标数据
func (m *TemplateManage) CreateDefaultTemplateAndQuota() {
	db := m.DataBase.DB()

	// 根据data.json中的默认模板数据创建或更新模板
	for _, templateCfg := range cfg.Data.DefaultTemplateList {
		// 检查模板是否已存在
		var existingTemplate dbModel.Template
		err := db.Where("id = ?", templateCfg.Id).First(&existingTemplate).Error
		
		if err != nil && err.Error() == "record not found" {
			// 模板不存在，创建新模板
			fmt.Printf("创建默认模板: %s\n", templateCfg.Name)
			m.createNewTemplate(db, templateCfg)
		} else if err != nil {
			// 数据库查询出错
			fmt.Printf("查询模板失败: %v\n", err)
		} else {
			// 模板已存在，检查是否需要更新
			fmt.Printf("检查默认模板是否需要更新: %s\n", templateCfg.Name)
			m.updateExistingTemplate(db, templateCfg, existingTemplate)
		}
	}
}

// 创建新模板及其指标
func (m *TemplateManage) createNewTemplate(db *gorm.DB, templateCfg cfg.TemplateCfg) {
	template := dbModel.Template{
		Id:             templateCfg.Id,
		Name:           templateCfg.Name,
		CreateUserCode: templateCfg.CreateUserCode,
		Note:           templateCfg.Note,
		DefaultTemplate: true,
		CreateTime:     time.Now(),
		UpdateTime:     time.Now(),
	}

	if err := db.Create(&template).Error; err != nil {
		fmt.Printf("创建模板失败: %v\n", err)
		return
	}

	// 创建指标
	m.createQuotasForTemplate(db, templateCfg)
}

// 更新已存在的模板
func (m *TemplateManage) updateExistingTemplate(db *gorm.DB, templateCfg cfg.TemplateCfg, existingTemplate dbModel.Template) {
	// 检查模板基本信息是否需要更新
	needUpdate := false
	updateData := map[string]interface{}{}

	if existingTemplate.Name != templateCfg.Name {
		updateData["name"] = templateCfg.Name
		needUpdate = true
	}
	if existingTemplate.CreateUserCode != templateCfg.CreateUserCode {
		updateData["create_user_code"] = templateCfg.CreateUserCode
		needUpdate = true
	}
	if existingTemplate.Note != templateCfg.Note {
		updateData["note"] = templateCfg.Note
		needUpdate = true
	}

	// 更新模板基本信息
	if needUpdate {
		updateData["update_time"] = time.Now()
		if err := db.Model(&dbModel.Template{}).Where("id = ?", templateCfg.Id).Updates(updateData).Error; err != nil {
			fmt.Printf("更新模板信息失败: %v\n", err)
		} else {
			fmt.Printf("已更新模板信息: %s\n", templateCfg.Name)
		}
	}

	// 更新指标信息（只更新已存在的指标，不删除不创建新指标以保护数据完整性）
	m.updateQuotasForTemplate(db, templateCfg)
}

// 为模板创建指标
func (m *TemplateManage) createQuotasForTemplate(db *gorm.DB, templateCfg cfg.TemplateCfg) {
	// 创建一级指标
	for _, quotaCfg := range templateCfg.QuotaList {
		quotaId := commUtils.GenUUID()

		quota := dbModel.Quota{
			Id:                 quotaId,
			Name:               quotaCfg.Name,
			Level:              quotaCfg.Level,
			EvaluationCriteria: quotaCfg.EvaluationCriteria,
			EvaluationLevel:    quotaCfg.EvaluationLevel,
			EvaluationScore:    quotaCfg.EvaluationScore,
			Note:               quotaCfg.Note,
			TemplateId:         templateCfg.Id,
			ParentQuotaId:      "", // 一级指标parentQuotaId为空
			CreateTime:         time.Now(),
			UpdateTime:         time.Now(),
		}

		if err := db.Create(&quota).Error; err != nil {
			fmt.Printf("创建一级指标失败: %v\n", err)
			continue
		}

		// 创建二级指标
		for _, childQuotaCfg := range quotaCfg.Children {
			childQuotaId := commUtils.GenUUID()

			childQuota := dbModel.Quota{
				Id:                 childQuotaId,
				Name:               childQuotaCfg.Name,
				Level:              childQuotaCfg.Level,
				EvaluationCriteria: childQuotaCfg.EvaluationCriteria,
				EvaluationLevel:    childQuotaCfg.EvaluationLevel,
				EvaluationScore:    childQuotaCfg.EvaluationScore,
				Note:               childQuotaCfg.Note,
				TemplateId:         templateCfg.Id,
				ParentQuotaId:      quotaId, // 二级指标parentQuotaId为对应一级指标的id
				CreateTime:         time.Now(),
				UpdateTime:         time.Now(),
			}

			if err := db.Create(&childQuota).Error; err != nil {
				fmt.Printf("创建二级指标失败: %v\n", err)
			}
		}
	}
}

// 更新模板的指标信息
func (m *TemplateManage) updateQuotasForTemplate(db *gorm.DB, templateCfg cfg.TemplateCfg) {
	// 获取当前模板的所有指标
	var existingQuotas []dbModel.Quota
	if err := db.Where("template_id = ?", templateCfg.Id).Find(&existingQuotas).Error; err != nil {
		fmt.Printf("查询现有指标失败: %v\n", err)
		return
	}

	// 根据名称和层级匹配指标进行更新
	for _, quotaCfg := range templateCfg.QuotaList {
		// 查找对应的一级指标
		foundParentQuota := false
		for i, existingQuota := range existingQuotas {
			if existingQuota.Name == quotaCfg.Name && existingQuota.Level == quotaCfg.Level && existingQuota.ParentQuotaId == "" {
				// 更新一级指标
				m.updateQuotaIfNeeded(db, existingQuota, quotaCfg)
				foundParentQuota = true
				
				// 更新二级指标
				for _, childQuotaCfg := range quotaCfg.Children {
					foundChildQuota := false
					for j, existingChildQuota := range existingQuotas {
						if existingChildQuota.Name == childQuotaCfg.Name && 
						   existingChildQuota.Level == childQuotaCfg.Level && 
						   existingChildQuota.ParentQuotaId == existingQuota.Id {
							m.updateQuotaIfNeeded(db, existingChildQuota, childQuotaCfg)
							foundChildQuota = true
							break
						}
						_ = j // 避免未使用变量警告
					}
					
					// 如果二级指标不存在，创建新的二级指标
					if !foundChildQuota {
						fmt.Printf("创建新的二级指标: %s (父指标: %s)\n", childQuotaCfg.Name, quotaCfg.Name)
						m.createSingleQuota(db, childQuotaCfg, templateCfg.Id, existingQuota.Id)
					}
				}
				break
			}
			_ = i // 避免未使用变量警告
		}
		
		// 如果一级指标不存在，创建新的一级指标及其子指标
		if !foundParentQuota {
			fmt.Printf("创建新的一级指标: %s\n", quotaCfg.Name)
			parentQuotaId := m.createSingleQuota(db, quotaCfg, templateCfg.Id, "")
			
			// 创建该一级指标下的所有二级指标
			for _, childQuotaCfg := range quotaCfg.Children {
				fmt.Printf("创建新的二级指标: %s (父指标: %s)\n", childQuotaCfg.Name, quotaCfg.Name)
				m.createSingleQuota(db, childQuotaCfg, templateCfg.Id, parentQuotaId)
			}
		}
	}
}

// 创建单个指标
func (m *TemplateManage) createSingleQuota(db *gorm.DB, quotaCfg cfg.QuotaCfg, templateId string, parentQuotaId string) string {
	quotaId := commUtils.GenUUID()
	
	quota := dbModel.Quota{
		Id:                 quotaId,
		Name:               quotaCfg.Name,
		Level:              quotaCfg.Level,
		EvaluationCriteria: quotaCfg.EvaluationCriteria,
		EvaluationLevel:    quotaCfg.EvaluationLevel,
		EvaluationScore:    quotaCfg.EvaluationScore,
		Note:               quotaCfg.Note,
		TemplateId:         templateId,
		ParentQuotaId:      parentQuotaId,
		CreateTime:         time.Now(),
		UpdateTime:         time.Now(),
	}

	if err := db.Create(&quota).Error; err != nil {
		fmt.Printf("创建指标失败: %v\n", err)
		return ""
	}
	
	fmt.Printf("成功创建指标: %s\n", quotaCfg.Name)
	return quotaId
}

// 检查并更新指标信息
func (m *TemplateManage) updateQuotaIfNeeded(db *gorm.DB, existingQuota dbModel.Quota, quotaCfg cfg.QuotaCfg) {
	needUpdate := false
	updateData := map[string]interface{}{}

	// 检查需要更新的字段
	if existingQuota.EvaluationCriteria != quotaCfg.EvaluationCriteria {
		updateData["evaluation_criteria"] = quotaCfg.EvaluationCriteria
		needUpdate = true
	}
	if existingQuota.EvaluationLevel != quotaCfg.EvaluationLevel {
		updateData["evaluation_level"] = quotaCfg.EvaluationLevel
		needUpdate = true
	}
	
	// 比较 EvaluationScore（注意一个是指针，一个可能不是）
	if (existingQuota.EvaluationScore == nil && quotaCfg.EvaluationScore != nil) ||
	   (existingQuota.EvaluationScore != nil && quotaCfg.EvaluationScore == nil) ||
	   (existingQuota.EvaluationScore != nil && quotaCfg.EvaluationScore != nil && *existingQuota.EvaluationScore != *quotaCfg.EvaluationScore) {
		updateData["evaluation_score"] = quotaCfg.EvaluationScore
		needUpdate = true
	}

	if existingQuota.Note != quotaCfg.Note {
		updateData["note"] = quotaCfg.Note
		needUpdate = true
	}

	// 执行更新
	if needUpdate {
		updateData["update_time"] = time.Now()
		if err := db.Model(&dbModel.Quota{}).Where("id = ?", existingQuota.Id).Updates(updateData).Error; err != nil {
			fmt.Printf("更新指标失败: %v\n", err)
		} else {
			fmt.Printf("已更新指标: %s\n", existingQuota.Name)
		}
	}
}
